#region Copyright & License

//
// Copyright 2001-2005 The Apache Software Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//

#endregion

using System;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Permissions;
using System.Security.Principal;
using System.Threading;
using log4net.Repository;
using log4net.Util;

#if (!NETCF)
#endif

namespace log4net.Core {
  /// <summary>
  /// Portable data structure used by <see cref="LoggingEvent"/>
  /// </summary>
  /// <remarks>
  /// <para>
  /// Portable data structure used by <see cref="LoggingEvent"/>
  /// </para>
  /// </remarks>
  /// <author>Nicko Cadell</author>
  public struct LoggingEventData {
    #region Public Instance Fields

    /// <summary>
    /// String representation of the AppDomain.
    /// </summary>
    /// <remarks>
    /// <para>
    /// String representation of the AppDomain.
    /// </para>
    /// </remarks>
    public string Domain;

    /// <summary>
    /// The string representation of the exception
    /// </summary>
    /// <remarks>
    /// <para>
    /// The string representation of the exception
    /// </para>
    /// </remarks>
    public string ExceptionString;

    /// <summary>
    /// String representation of the identity.
    /// </summary>
    /// <remarks>
    /// <para>
    /// String representation of the current thread's principal identity.
    /// </para>
    /// </remarks>
    public string Identity;

    /// <summary>
    /// Level of logging event.
    /// </summary>
    /// <remarks>
    /// <para>
    /// Level of logging event. Level cannot be Serializable
    /// because it is a flyweight.  Due to its special serialization it
    /// cannot be declared final either.
    /// </para>
    /// </remarks>
    public Level Level;

    /// <summary>
    /// Location information for the caller.
    /// </summary>
    /// <remarks>
    /// <para>
    /// Location information for the caller.
    /// </para>
    /// </remarks>
    public LocationInfo LocationInfo;

    /// <summary>
    /// The logger name.
    /// </summary>
    /// <remarks>
    /// <para>
    /// The logger name.
    /// </para>
    /// </remarks>
    public string LoggerName;

    /// <summary>
    /// The application supplied message.
    /// </summary>
    /// <remarks>
    /// <para>
    /// The application supplied message of logging event.
    /// </para>
    /// </remarks>
    public string Message;

    /// <summary>
    /// Additional event specific properties
    /// </summary>
    /// <remarks>
    /// <para>
    /// A logger or an appender may attach additional
    /// properties to specific events. These properties
    /// have a string key and an object value.
    /// </para>
    /// </remarks>
    public PropertiesDictionary Properties;

    /// <summary>
    /// The name of thread
    /// </summary>
    /// <remarks>
    /// <para>
    /// The name of thread in which this logging event was generated
    /// </para>
    /// </remarks>
    public string ThreadName;

    /// <summary>
    /// The time the event was logged
    /// </summary>
    /// <remarks>
    /// <para>
    /// The TimeStamp is stored in the local time zone for this computer.
    /// </para>
    /// </remarks>
    public DateTime TimeStamp;

    /// <summary>
    /// String representation of the user
    /// </summary>
    /// <remarks>
    /// <para>
    /// String representation of the user's windows name,
    /// like DOMAIN\username
    /// </para>
    /// </remarks>
    public string UserName;

    #endregion Public Instance Fields
  }

  /// <summary>
  /// Flags passed to the <see cref="LoggingEvent.Fix"/> property
  /// </summary>
  /// <remarks>
  /// <para>
  /// Flags passed to the <see cref="LoggingEvent.Fix"/> property
  /// </para>
  /// </remarks>
  /// <author>Nicko Cadell</author>
  [Flags]
  public enum FixFlags {
    /// <summary>
    /// Fix the MDC
    /// </summary>
    [Obsolete("Replaced by composite Properties")] Mdc = 0x01,

    /// <summary>
    /// Fix the NDC
    /// </summary>
    Ndc = 0x02,

    /// <summary>
    /// Fix the rendered message
    /// </summary>
    Message = 0x04,

    /// <summary>
    /// Fix the thread name
    /// </summary>
    ThreadName = 0x08,

    /// <summary>
    /// Fix the callers location information
    /// </summary>
    /// <remarks>
    /// CAUTION: Very slow to generate
    /// </remarks>
    LocationInfo = 0x10,

    /// <summary>
    /// Fix the callers windows user name
    /// </summary>
    /// <remarks>
    /// CAUTION: Slow to generate
    /// </remarks>
    UserName = 0x20,

    /// <summary>
    /// Fix the domain friendly name
    /// </summary>
    Domain = 0x40,

    /// <summary>
    /// Fix the callers principal name
    /// </summary>
    /// <remarks>
    /// CAUTION: May be slow to generate
    /// </remarks>
    Identity = 0x80,

    /// <summary>
    /// Fix the exception text
    /// </summary>
    Exception = 0x100,

    /// <summary>
    /// Fix the event properties
    /// </summary>
    Properties = 0x200,

    /// <summary>
    /// No fields fixed
    /// </summary>
    None = 0x0,

    /// <summary>
    /// All fields fixed
    /// </summary>
    All = 0xFFFFFFF,

    /// <summary>
    /// Partial fields fixed
    /// </summary>
    /// <remarks>
    /// <para>
    /// This set of partial fields gives good performance. The following fields are fixed:
    /// </para>
    /// <list type="bullet">
    /// <item><description><see cref="Message"/></description></item>
    /// <item><description><see cref="ThreadName"/></description></item>
    /// <item><description><see cref="Exception"/></description></item>
    /// <item><description><see cref="Domain"/></description></item>
    /// <item><description><see cref="Properties"/></description></item>
    /// </list>
    /// </remarks>
    Partial = Message | ThreadName | Exception | Domain | Properties,
  }

  /// <summary>
  /// The internal representation of logging events. 
  /// </summary>
  /// <remarks>
  /// <para>
  /// When an affirmative decision is made to log then a 
  /// <see cref="LoggingEvent"/> instance is created. This instance 
  /// is passed around to the different log4net components.
  /// </para>
  /// <para>
  /// This class is of concern to those wishing to extend log4net.
  /// </para>
  /// <para>
  /// Some of the values in instances of <see cref="LoggingEvent"/>
  /// are considered volatile, that is the values are correct at the
  /// time the event is delivered to appenders, but will not be consistent
  /// at any time afterwards. If an event is to be stored and then processed
  /// at a later time these volatile values must be fixed by calling
  /// <see cref="FixVolatileData()"/>. There is a performance penalty
  /// for incurred by calling <see cref="FixVolatileData()"/> but it
  /// is essential to maintaining data consistency.
  /// </para>
  /// </remarks>
  /// <author>Nicko Cadell</author>
  /// <author>Gert Driesen</author>
  /// <author>Douglas de la Torre</author>
  /// <author>Daniel Cazzulino</author>
#if !NETCF
  [Serializable]
#endif
  public class LoggingEvent
#if !NETCF
    : ISerializable
#endif
  {
    #region Public Instance Constructors

    /// <summary>
    /// Initializes a new instance of the <see cref="LoggingEvent" /> class
    /// from the supplied parameters.
    /// </summary>
    /// <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
    /// the stack boundary into the logging system for this call.</param>
    /// <param name="repository">The repository this event is logged in.</param>
    /// <param name="loggerName">The name of the logger of this event.</param>
    /// <param name="level">The level of this event.</param>
    /// <param name="message">The message of this event.</param>
    /// <param name="exception">The exception for this event.</param>
    /// <remarks>
    /// <para>
    /// Except <see cref="TimeStamp"/>, <see cref="Level"/> and <see cref="LoggerName"/>, 
    /// all fields of <c>LoggingEvent</c> are filled when actually needed. Call
    /// <see cref="FixVolatileData()"/> to cache all data locally
    /// to prevent inconsistencies.
    /// </para>
    /// <para>This method is called by the log4net framework
    /// to create a logging event.
    /// </para>
    /// </remarks>
    public LoggingEvent(Type callerStackBoundaryDeclaringType, ILoggerRepository repository, string loggerName,
                        Level level, object message, Exception exception) {
      m_callerStackBoundaryDeclaringType = callerStackBoundaryDeclaringType;
      m_message = message;
      m_repository = repository;
      m_thrownException = exception;

      m_data.LoggerName = loggerName;
      m_data.Level = level;

      // Store the event creation time
      m_data.TimeStamp = DateTime.Now;
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="LoggingEvent" /> class 
    /// using specific data.
    /// </summary>
    /// <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
    /// the stack boundary into the logging system for this call.</param>
    /// <param name="repository">The repository this event is logged in.</param>
    /// <param name="data">Data used to initialize the logging event.</param>
    /// <param name="fixedData">The fields in the <paranref name="data"/> struct that have already been fixed.</param>
    /// <remarks>
    /// <para>
    /// This constructor is provided to allow a <see cref="LoggingEvent" />
    /// to be created independently of the log4net framework. This can
    /// be useful if you require a custom serialization scheme.
    /// </para>
    /// <para>
    /// Use the <see cref="GetLoggingEventData(FixFlags)"/> method to obtain an 
    /// instance of the <see cref="LoggingEventData"/> class.
    /// </para>
    /// <para>
    /// The <paramref name="fixedData"/> parameter should be used to specify which fields in the
    /// <paramref name="data"/> struct have been preset. Fields not specified in the <paramref name="fixedData"/>
    /// will be captured from the environment if requested or fixed.
    /// </para>
    /// </remarks>
    public LoggingEvent(Type callerStackBoundaryDeclaringType, ILoggerRepository repository, LoggingEventData data,
                        FixFlags fixedData) {
      m_callerStackBoundaryDeclaringType = callerStackBoundaryDeclaringType;
      m_repository = repository;

      m_data = data;
      m_fixFlags = fixedData;
    }

    /// <summary>
    /// Initializes a new instance of the <see cref="LoggingEvent" /> class 
    /// using specific data.
    /// </summary>
    /// <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
    /// the stack boundary into the logging system for this call.</param>
    /// <param name="repository">The repository this event is logged in.</param>
    /// <param name="data">Data used to initialize the logging event.</param>
    /// <remarks>
    /// <para>
    /// This constructor is provided to allow a <see cref="LoggingEvent" />
    /// to be created independently of the log4net framework. This can
    /// be useful if you require a custom serialization scheme.
    /// </para>
    /// <para>
    /// Use the <see cref="GetLoggingEventData(FixFlags)"/> method to obtain an 
    /// instance of the <see cref="LoggingEventData"/> class.
    /// </para>
    /// <para>
    /// This constructor sets this objects <see cref="Fix"/> flags to <see cref="FixFlags.All"/>,
    /// this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
    /// parameter and no other data should be captured from the environment.
    /// </para>
    /// </remarks>
    public LoggingEvent(Type callerStackBoundaryDeclaringType, ILoggerRepository repository, LoggingEventData data)
      : this(callerStackBoundaryDeclaringType, repository, data, FixFlags.All) {}

    /// <summary>
    /// Initializes a new instance of the <see cref="LoggingEvent" /> class 
    /// using specific data.
    /// </summary>
    /// <param name="data">Data used to initialize the logging event.</param>
    /// <remarks>
    /// <para>
    /// This constructor is provided to allow a <see cref="LoggingEvent" />
    /// to be created independently of the log4net framework. This can
    /// be useful if you require a custom serialization scheme.
    /// </para>
    /// <para>
    /// Use the <see cref="GetLoggingEventData(FixFlags)"/> method to obtain an 
    /// instance of the <see cref="LoggingEventData"/> class.
    /// </para>
    /// <para>
    /// This constructor sets this objects <see cref="Fix"/> flags to <see cref="FixFlags.All"/>,
    /// this assumes that all the data relating to this event is passed in via the <paramref name="data"/>
    /// parameter and no other data should be captured from the environment.
    /// </para>
    /// </remarks>
    public LoggingEvent(LoggingEventData data) : this(null, null, data) {}

    #endregion Public Instance Constructors

    #region Protected Instance Constructors

#if !NETCF

    /// <summary>
    /// Serialization constructor
    /// </summary>
    /// <param name="info">The <see cref="SerializationInfo" /> that holds the serialized object data.</param>
    /// <param name="context">The <see cref="StreamingContext" /> that contains contextual information about the source or destination.</param>
    /// <remarks>
    /// <para>
    /// Initializes a new instance of the <see cref="LoggingEvent" /> class 
    /// with serialized data.
    /// </para>
    /// </remarks>
    protected LoggingEvent(SerializationInfo info, StreamingContext context) {
      m_data.LoggerName = info.GetString("LoggerName");

      // Note we are deserializing the whole level object. That is the
      // name and the value. This value is correct for the source 
      // hierarchy but may not be for the target hierarchy that this
      // event may be re-logged into. If it is to be re-logged it may
      // be necessary to re-lookup the level based only on the name.
      m_data.Level = (Level) info.GetValue("Level", typeof (Level));

      m_data.Message = info.GetString("Message");
      m_data.ThreadName = info.GetString("ThreadName");
      m_data.TimeStamp = info.GetDateTime("TimeStamp");
      m_data.LocationInfo = (LocationInfo) info.GetValue("LocationInfo", typeof (LocationInfo));
      m_data.UserName = info.GetString("UserName");
      m_data.ExceptionString = info.GetString("ExceptionString");
      m_data.Properties = (PropertiesDictionary) info.GetValue("Properties", typeof (PropertiesDictionary));
      m_data.Domain = info.GetString("Domain");
      m_data.Identity = info.GetString("Identity");

      // We have restored all the values of this instance, i.e. all the values are fixed
      // Set the fix flags otherwise the data values may be overwritten from the current environment.
      m_fixFlags = FixFlags.All;
    }

#endif

    #endregion Protected Instance Constructors

    #region Public Instance Properties

    /// <summary>
    /// Gets the time when the current process started.
    /// </summary>
    /// <value>
    /// This is the time when this process started.
    /// </value>
    /// <remarks>
    /// <para>
    /// The TimeStamp is stored in the local time zone for this computer.
    /// </para>
    /// <para>
    /// Tries to get the start time for the current process.
    /// Failing that it returns the time of the first call to
    /// this property.
    /// </para>
    /// <para>
    /// Note that AppDomains may be loaded and unloaded within the
    /// same process without the process terminating and therefore
    /// without the process start time being reset.
    /// </para>
    /// </remarks>
    public static DateTime StartTime {
      get { return SystemInfo.ProcessStartTime; }
    }

    /// <summary>
    /// Gets the <see cref="Level" /> of the logging event.
    /// </summary>
    /// <value>
    /// The <see cref="Level" /> of the logging event.
    /// </value>
    /// <remarks>
    /// <para>
    /// Gets the <see cref="Level" /> of the logging event.
    /// </para>
    /// </remarks>
    public Level Level {
      get { return m_data.Level; }
    }

    /// <summary>
    /// Gets the time of the logging event.
    /// </summary>
    /// <value>
    /// The time of the logging event.
    /// </value>
    /// <remarks>
    /// <para>
    /// The TimeStamp is stored in the local time zone for this computer.
    /// </para>
    /// </remarks>
    public DateTime TimeStamp {
      get { return m_data.TimeStamp; }
    }

    /// <summary>
    /// Gets the name of the logger that logged the event.
    /// </summary>
    /// <value>
    /// The name of the logger that logged the event.
    /// </value>
    /// <remarks>
    /// <para>
    /// Gets the name of the logger that logged the event.
    /// </para>
    /// </remarks>
    public string LoggerName {
      get { return m_data.LoggerName; }
    }

    /// <summary>
    /// Gets the location information for this logging event.
    /// </summary>
    /// <value>
    /// The location information for this logging event.
    /// </value>
    /// <remarks>
    /// <para>
    /// The collected information is cached for future use.
    /// </para>
    /// <para>
    /// See the <see cref="LocationInfo"/> class for more information on
    /// supported frameworks and the different behavior in Debug and
    /// Release builds.
    /// </para>
    /// </remarks>
    public LocationInfo LocationInformation {
      get {
        if (m_data.LocationInfo == null && m_cacheUpdatable)
          m_data.LocationInfo = new LocationInfo(m_callerStackBoundaryDeclaringType);
        return m_data.LocationInfo;
      }
    }

    /// <summary>
    /// Gets the message object used to initialize this event.
    /// </summary>
    /// <value>
    /// The message object used to initialize this event.
    /// </value>
    /// <remarks>
    /// <para>
    /// Gets the message object used to initialize this event.
    /// Note that this event may not have a valid message object.
    /// If the event is serialized the message object will not 
    /// be transferred. To get the text of the message the
    /// <see cref="RenderedMessage"/> property must be used 
    /// not this property.
    /// </para>
    /// <para>
    /// If there is no defined message object for this event then
    /// null will be returned.
    /// </para>
    /// </remarks>
    public object MessageObject {
      get { return m_message; }
    }

    /// <summary>
    /// Gets the exception object used to initialize this event.
    /// </summary>
    /// <value>
    /// The exception object used to initialize this event.
    /// </value>
    /// <remarks>
    /// <para>
    /// Gets the exception object used to initialize this event.
    /// Note that this event may not have a valid exception object.
    /// If the event is serialized the exception object will not 
    /// be transferred. To get the text of the exception the
    /// <see cref="GetExceptionString"/> method must be used 
    /// not this property.
    /// </para>
    /// <para>
    /// If there is no defined exception object for this event then
    /// null will be returned.
    /// </para>
    /// </remarks>
    public Exception ExceptionObject {
      get { return m_thrownException; }
    }

    /// <summary>
    /// The <see cref="ILoggerRepository"/> that this event was created in.
    /// </summary>
    /// <remarks>
    /// <para>
    /// The <see cref="ILoggerRepository"/> that this event was created in.
    /// </para>
    /// </remarks>
    public ILoggerRepository Repository {
      get { return m_repository; }
    }

    /// <summary>
    /// Gets the message, rendered through the <see cref="ILoggerRepository.RendererMap" />.
    /// </summary>
    /// <value>
    /// The message rendered through the <see cref="ILoggerRepository.RendererMap" />.
    /// </value>
    /// <remarks>
    /// <para>
    /// The collected information is cached for future use.
    /// </para>
    /// </remarks>
    public string RenderedMessage {
      get {
        if (m_data.Message == null && m_cacheUpdatable)
          if (m_message == null)
            m_data.Message = "";
          else if (m_message is string)
            m_data.Message = (m_message as string);
          else if (m_repository != null)
            m_data.Message = m_repository.RendererMap.FindAndRender(m_message);
          else // Very last resort
            m_data.Message = m_message.ToString();
        return m_data.Message;
      }
    }

    /// <summary>
    /// Gets the name of the current thread.  
    /// </summary>
    /// <value>
    /// The name of the current thread, or the thread ID when 
    /// the name is not available.
    /// </value>
    /// <remarks>
    /// <para>
    /// The collected information is cached for future use.
    /// </para>
    /// </remarks>
    public string ThreadName {
      get {
        if (m_data.ThreadName == null && m_cacheUpdatable) {
#if NETCF
  // Get thread ID only
					m_data.ThreadName = SystemInfo.CurrentThreadId.ToString(System.Globalization.NumberFormatInfo.InvariantInfo);
#else
          m_data.ThreadName = Thread.CurrentThread.Name;
          if (m_data.ThreadName == null || m_data.ThreadName.Length == 0)
            // The thread name is not available. Therefore we
            // go the the AppDomain to get the ID of the 
            // current thread. (Why don't Threads know their own ID?)
            try {
              m_data.ThreadName = SystemInfo.CurrentThreadId.ToString(NumberFormatInfo.InvariantInfo);
            } catch (SecurityException) {
              // This security exception will occur if the caller does not have 
              // some undefined set of SecurityPermission flags.
              LogLog.Debug(
                "LoggingEvent: Security exception while trying to get current thread ID. Error Ignored. Empty thread name.");

              // As a last resort use the hash code of the Thread object
              m_data.ThreadName = Thread.CurrentThread.GetHashCode().ToString(CultureInfo.InvariantCulture);
            }
#endif
        }
        return m_data.ThreadName;
      }
    }

    /// <summary>
    /// Gets the name of the current user.
    /// </summary>
    /// <value>
    /// The name of the current user, or <c>NOT AVAILABLE</c> when the 
    /// underlying runtime has no support for retrieving the name of the 
    /// current user.
    /// </value>
    /// <remarks>
    /// <para>
    /// Calls <c>WindowsIdentity.GetCurrent().Name</c> to get the name of
    /// the current windows user.
    /// </para>
    /// <para>
    /// To improve performance, we could cache the string representation of 
    /// the name, and reuse that as long as the identity stayed constant.  
    /// Once the identity changed, we would need to re-assign and re-render 
    /// the string.
    /// </para>
    /// <para>
    /// However, the <c>WindowsIdentity.GetCurrent()</c> call seems to 
    /// return different objects every time, so the current implementation 
    /// doesn't do this type of caching.
    /// </para>
    /// <para>
    /// Timing for these operations:
    /// </para>
    /// <list type="table">
    ///   <listheader>
    ///     <term>Method</term>
    ///     <description>Results</description>
    ///   </listheader>
    ///   <item>
    ///	    <term><c>WindowsIdentity.GetCurrent()</c></term>
    ///	    <description>10000 loops, 00:00:00.2031250 seconds</description>
    ///   </item>
    ///   <item>
    ///	    <term><c>WindowsIdentity.GetCurrent().Name</c></term>
    ///	    <description>10000 loops, 00:00:08.0468750 seconds</description>
    ///   </item>
    /// </list>
    /// <para>
    /// This means we could speed things up almost 40 times by caching the 
    /// value of the <c>WindowsIdentity.GetCurrent().Name</c> property, since 
    /// this takes (8.04-0.20) = 7.84375 seconds.
    /// </para>
    /// </remarks>
    public string UserName {
      get {
        if (m_data.UserName == null && m_cacheUpdatable)
#if (NETCF || SSCLI)
  // On compact framework there's no notion of current Windows user
					m_data.UserName = SystemInfo.NotAvailableText;
#else
          try {
            WindowsIdentity windowsIdentity = WindowsIdentity.GetCurrent();
            if (windowsIdentity != null && windowsIdentity.Name != null)
              m_data.UserName = windowsIdentity.Name;
            else
              m_data.UserName = "";
          } catch (SecurityException) {
            // This security exception will occur if the caller does not have 
            // some undefined set of SecurityPermission flags.
            LogLog.Debug(
              "LoggingEvent: Security exception while trying to get current windows identity. Error Ignored. Empty user name.");

            m_data.UserName = "";
          }
#endif
        return m_data.UserName;
      }
    }

    /// <summary>
    /// Gets the identity of the current thread principal.
    /// </summary>
    /// <value>
    /// The string name of the identity of the current thread principal.
    /// </value>
    /// <remarks>
    /// <para>
    /// Calls <c>System.Threading.Thread.CurrentPrincipal.Identity.Name</c> to get
    /// the name of the current thread principal.
    /// </para>
    /// </remarks>
    public string Identity {
      get {
        if (m_data.Identity == null && m_cacheUpdatable)
#if (NETCF || SSCLI)
  // On compact framework there's no notion of current thread principals
					m_data.Identity = SystemInfo.NotAvailableText;
#else
          try {
            if (Thread.CurrentPrincipal != null &&
                Thread.CurrentPrincipal.Identity != null &&
                Thread.CurrentPrincipal.Identity.Name != null)
              m_data.Identity = Thread.CurrentPrincipal.Identity.Name;
            else
              m_data.Identity = "";
          } catch (SecurityException) {
            // This security exception will occur if the caller does not have 
            // some undefined set of SecurityPermission flags.
            LogLog.Debug(
              "LoggingEvent: Security exception while trying to get current thread principal. Error Ignored. Empty identity name.");

            m_data.Identity = "";
          }
#endif
        return m_data.Identity;
      }
    }

    /// <summary>
    /// Gets the AppDomain friendly name.
    /// </summary>
    /// <value>
    /// The AppDomain friendly name.
    /// </value>
    /// <remarks>
    /// <para>
    /// Gets the AppDomain friendly name.
    /// </para>
    /// </remarks>
    public string Domain {
      get {
        if (m_data.Domain == null && m_cacheUpdatable)
          m_data.Domain = SystemInfo.ApplicationFriendlyName;
        return m_data.Domain;
      }
    }

    /// <summary>
    /// Additional event specific properties.
    /// </summary>
    /// <value>
    /// Additional event specific properties.
    /// </value>
    /// <remarks>
    /// <para>
    /// A logger or an appender may attach additional
    /// properties to specific events. These properties
    /// have a string key and an object value.
    /// </para>
    /// <para>
    /// This property is for events that have been added directly to
    /// this event. The aggregate properties (which include these
    /// event properties) can be retrieved using <see cref="LookupProperty"/>
    /// and <see cref="GetProperties"/>.
    /// </para>
    /// <para>
    /// Once the properties have been fixed <see cref="Fix"/> this property
    /// returns the combined cached properties. This ensures that updates to
    /// this property are always reflected in the underlying storage. When
    /// returning the combined properties there may be more keys in the
    /// Dictionary than expected.
    /// </para>
    /// </remarks>
    public PropertiesDictionary Properties {
      get {
        // If we have cached properties then return that otherwise changes will be lost
        if (m_data.Properties != null)
          return m_data.Properties;

        if (m_eventProperties == null)
          m_eventProperties = new PropertiesDictionary();
        return m_eventProperties;
      }
    }

    /// <summary>
    /// The fixed fields in this event
    /// </summary>
    /// <value>
    /// The set of fields that are fixed in this event
    /// </value>
    /// <remarks>
    /// <para>
    /// Fields will not be fixed if they have previously been fixed.
    /// It is not possible to 'unfix' a field.
    /// </para>
    /// </remarks>
    public FixFlags Fix {
      get { return m_fixFlags; }
      set { FixVolatileData(value); }
    }

    /// <summary>
    /// Ensure that the repository is set.
    /// </summary>
    /// <param name="repository">the value for the repository</param>
    internal void EnsureRepository(ILoggerRepository repository) {
      if (repository != null)
        m_repository = repository;
    }

    /// <summary>
    /// Write the rendered message to a TextWriter
    /// </summary>
    /// <param name="writer">the writer to write the message to</param>
    /// <remarks>
    /// <para>
    /// Unlike the <see cref="RenderedMessage"/> property this method
    /// does store the message data in the internal cache. Therefore 
    /// if called only once this method should be faster than the
    /// <see cref="RenderedMessage"/> property, however if the message is
    /// to be accessed multiple times then the property will be more efficient.
    /// </para>
    /// </remarks>
    public void WriteRenderedMessage(TextWriter writer) {
      if (m_data.Message != null)
        writer.Write(m_data.Message);
      else if (m_message != null)
        if (m_message is string)
          writer.Write(m_message as string);
        else if (m_repository != null)
          m_repository.RendererMap.FindAndRender(m_message, writer);
        else // Very last resort
          writer.Write(m_message.ToString());
    }

    #endregion Public Instance Properties

    #region Implementation of ISerializable

#if !NETCF

    /// <summary>
    /// Serializes this object into the <see cref="SerializationInfo" /> provided.
    /// </summary>
    /// <param name="info">The <see cref="SerializationInfo" /> to populate with data.</param>
    /// <param name="context">The destination for this serialization.</param>
    /// <remarks>
    /// <para>
    /// The data in this event must be fixed before it can be serialized.
    /// </para>
    /// <para>
    /// The <see cref="FixVolatileData()"/> method must be called during the
    /// <see cref="log4net.Appender.IAppender.DoAppend"/> method call if this event 
    /// is to be used outside that method.
    /// </para>
    /// </remarks>
    [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
    public virtual void GetObjectData(SerializationInfo info, StreamingContext context) {
      // The caller must call FixVolatileData before this object
      // can be serialized.

      info.AddValue("LoggerName", m_data.LoggerName);
      info.AddValue("Level", m_data.Level);
      info.AddValue("Message", m_data.Message);
      info.AddValue("ThreadName", m_data.ThreadName);
      info.AddValue("TimeStamp", m_data.TimeStamp);
      info.AddValue("LocationInfo", m_data.LocationInfo);
      info.AddValue("UserName", m_data.UserName);
      info.AddValue("ExceptionString", m_data.ExceptionString);
      info.AddValue("Properties", m_data.Properties);
      info.AddValue("Domain", m_data.Domain);
      info.AddValue("Identity", m_data.Identity);
    }

#endif

    #endregion Implementation of ISerializable

    #region Public Instance Methods

    /// <summary>
    /// Gets the portable data for this <see cref="LoggingEvent" />.
    /// </summary>
    /// <returns>The <see cref="LoggingEventData"/> for this event.</returns>
    /// <remarks>
    /// <para>
    /// A new <see cref="LoggingEvent"/> can be constructed using a
    /// <see cref="LoggingEventData"/> instance.
    /// </para>
    /// <para>
    /// Does a <see cref="FixFlags.Partial"/> fix of the data
    /// in the logging event before returning the event data.
    /// </para>
    /// </remarks>
    public LoggingEventData GetLoggingEventData() {
      return GetLoggingEventData(FixFlags.Partial);
    }

    /// <summary>
    /// Gets the portable data for this <see cref="LoggingEvent" />.
    /// </summary>
    /// <param name="fixFlags">The set of data to ensure is fixed in the LoggingEventData</param>
    /// <returns>The <see cref="LoggingEventData"/> for this event.</returns>
    /// <remarks>
    /// <para>
    /// A new <see cref="LoggingEvent"/> can be constructed using a
    /// <see cref="LoggingEventData"/> instance.
    /// </para>
    /// </remarks>
    public LoggingEventData GetLoggingEventData(FixFlags fixFlags) {
      Fix = fixFlags;
      return m_data;
    }

    /// <summary>
    /// Returns this event's exception's rendered using the 
    /// <see cref="ILoggerRepository.RendererMap" />.
    /// </summary>
    /// <returns>
    /// This event's exception's rendered using the <see cref="ILoggerRepository.RendererMap" />.
    /// </returns>
    /// <remarks>
    /// <para>
    /// <b>Obsolete. Use <see cref="GetExceptionString"/> instead.</b>
    /// </para>
    /// </remarks>
    [Obsolete("Use GetExceptionString instead")]
    public string GetExceptionStrRep() {
      return GetExceptionString();
    }

    /// <summary>
    /// Returns this event's exception's rendered using the 
    /// <see cref="ILoggerRepository.RendererMap" />.
    /// </summary>
    /// <returns>
    /// This event's exception's rendered using the <see cref="ILoggerRepository.RendererMap" />.
    /// </returns>
    /// <remarks>
    /// <para>
    /// Returns this event's exception's rendered using the 
    /// <see cref="ILoggerRepository.RendererMap" />.
    /// </para>
    /// </remarks>
    public string GetExceptionString() {
      if (m_data.ExceptionString == null && m_cacheUpdatable)
        if (m_thrownException != null)
          if (m_repository != null) // Render exception using the repositories renderer map
            m_data.ExceptionString = m_repository.RendererMap.FindAndRender(m_thrownException);
          else // Very last resort
            m_data.ExceptionString = m_thrownException.ToString();
        else
          m_data.ExceptionString = "";
      return m_data.ExceptionString;
    }

    /// <summary>
    /// Fix instance fields that hold volatile data.
    /// </summary>
    /// <remarks>
    /// <para>
    /// Some of the values in instances of <see cref="LoggingEvent"/>
    /// are considered volatile, that is the values are correct at the
    /// time the event is delivered to appenders, but will not be consistent
    /// at any time afterwards. If an event is to be stored and then processed
    /// at a later time these volatile values must be fixed by calling
    /// <see cref="FixVolatileData()"/>. There is a performance penalty
    /// incurred by calling <see cref="FixVolatileData()"/> but it
    /// is essential to maintaining data consistency.
    /// </para>
    /// <para>
    /// Calling <see cref="FixVolatileData()"/> is equivalent to
    /// calling <see cref="FixVolatileData(bool)"/> passing the parameter
    /// <c>false</c>.
    /// </para>
    /// <para>
    /// See <see cref="FixVolatileData(bool)"/> for more
    /// information.
    /// </para>
    /// </remarks>
    [Obsolete("Use Fix property")]
    public void FixVolatileData() {
      Fix = FixFlags.All;
    }

    /// <summary>
    /// Fixes instance fields that hold volatile data.
    /// </summary>
    /// <param name="fastButLoose">Set to <c>true</c> to not fix data that takes a long time to fix.</param>
    /// <remarks>
    /// <para>
    /// Some of the values in instances of <see cref="LoggingEvent"/>
    /// are considered volatile, that is the values are correct at the
    /// time the event is delivered to appenders, but will not be consistent
    /// at any time afterwards. If an event is to be stored and then processed
    /// at a later time these volatile values must be fixed by calling
    /// <see cref="FixVolatileData()"/>. There is a performance penalty
    /// for incurred by calling <see cref="FixVolatileData()"/> but it
    /// is essential to maintaining data consistency.
    /// </para>
    /// <para>
    /// The <paramref name="fastButLoose"/> param controls the data that
    /// is fixed. Some of the data that can be fixed takes a long time to 
    /// generate, therefore if you do not require those settings to be fixed
    /// they can be ignored by setting the <paramref name="fastButLoose"/> param
    /// to <c>true</c>. This setting will ignore the <see cref="LocationInformation"/>
    /// and <see cref="UserName"/> settings.
    /// </para>
    /// <para>
    /// Set <paramref name="fastButLoose"/> to <c>false</c> to ensure that all 
    /// settings are fixed.
    /// </para>
    /// </remarks>
    [Obsolete("Use Fix property")]
    public void FixVolatileData(bool fastButLoose) {
      if (fastButLoose)
        Fix = FixFlags.Partial;
      else
        Fix = FixFlags.All;
    }

    /// <summary>
    /// Fix the fields specified by the <see cref="FixFlags"/> parameter
    /// </summary>
    /// <param name="flags">the fields to fix</param>
    /// <remarks>
    /// <para>
    /// Only fields specified in the <paramref name="flags"/> will be fixed.
    /// Fields will not be fixed if they have previously been fixed.
    /// It is not possible to 'unfix' a field.
    /// </para>
    /// </remarks>
    protected void FixVolatileData(FixFlags flags) {
      object forceCreation = null;

      //Unlock the cache so that new values can be stored
      //This may not be ideal if we are no longer in the correct context
      //and someone calls fix. 
      m_cacheUpdatable = true;

      // determine the flags that we are actually fixing
      FixFlags updateFlags = ((flags ^ m_fixFlags) & flags);

      if (updateFlags > 0) {
        if ((updateFlags & FixFlags.Message) != 0) {
          // Force the message to be rendered
          forceCreation = RenderedMessage;

          m_fixFlags |= FixFlags.Message;
        }
        if ((updateFlags & FixFlags.ThreadName) != 0) {
          // Grab the thread name
          forceCreation = ThreadName;

          m_fixFlags |= FixFlags.ThreadName;
        }

        if ((updateFlags & FixFlags.LocationInfo) != 0) {
          // Force the location information to be loaded
          forceCreation = LocationInformation;

          m_fixFlags |= FixFlags.LocationInfo;
        }
        if ((updateFlags & FixFlags.UserName) != 0) {
          // Grab the user name
          forceCreation = UserName;

          m_fixFlags |= FixFlags.UserName;
        }
        if ((updateFlags & FixFlags.Domain) != 0) {
          // Grab the domain name
          forceCreation = Domain;

          m_fixFlags |= FixFlags.Domain;
        }
        if ((updateFlags & FixFlags.Identity) != 0) {
          // Grab the identity
          forceCreation = Identity;

          m_fixFlags |= FixFlags.Identity;
        }

        if ((updateFlags & FixFlags.Exception) != 0) {
          // Force the exception text to be loaded
          forceCreation = GetExceptionString();

          m_fixFlags |= FixFlags.Exception;
        }

        if ((updateFlags & FixFlags.Properties) != 0) {
          CacheProperties();

          m_fixFlags |= FixFlags.Properties;
        }
      }

      // avoid warning CS0219
      if (forceCreation != null) {}

      //Finaly lock everything we've cached.
      m_cacheUpdatable = false;
    }

    #endregion Public Instance Methods

    #region Protected Instance Methods

    void CreateCompositeProperties() {
      m_compositeProperties = new CompositeProperties();

      if (m_eventProperties != null)
        m_compositeProperties.Add(m_eventProperties);
#if !NETCF
      PropertiesDictionary logicalThreadProperties = LogicalThreadContext.Properties.GetProperties(false);
      if (logicalThreadProperties != null)
        m_compositeProperties.Add(logicalThreadProperties);
#endif
      PropertiesDictionary threadProperties = ThreadContext.Properties.GetProperties(false);
      if (threadProperties != null)
        m_compositeProperties.Add(threadProperties);

      // TODO: Add Repository Properties

      m_compositeProperties.Add(GlobalContext.Properties.GetReadOnlyProperties());
    }

    void CacheProperties() {
      if (m_data.Properties == null && m_cacheUpdatable) {
        if (m_compositeProperties == null)
          CreateCompositeProperties();

        PropertiesDictionary flattenedProperties = m_compositeProperties.Flatten();

        var fixedProperties = new PropertiesDictionary();

        // Validate properties
        foreach (DictionaryEntry entry in flattenedProperties) {
          var key = entry.Key as string;

          if (key != null) {
            object val = entry.Value;

            // Fix any IFixingRequired objects
            var fixingRequired = val as IFixingRequired;
            if (fixingRequired != null)
              val = fixingRequired.GetFixedObject();

            // Strip keys with null values
            if (val != null)
              fixedProperties[key] = val;
          }
        }

        m_data.Properties = fixedProperties;
      }
    }

    /// <summary>
    /// Lookup a composite property in this event
    /// </summary>
    /// <param name="key">the key for the property to lookup</param>
    /// <returns>the value for the property</returns>
    /// <remarks>
    /// <para>
    /// This event has composite properties that combine together properties from
    /// several different contexts in the following order:
    /// <list type="definition">
    ///		<item>
    /// 		<term>this events properties</term>
    /// 		<description>
    /// 		This event has <see cref="Properties"/> that can be set. These 
    /// 		properties are specific to this event only.
    /// 		</description>
    /// 	</item>
    /// 	<item>
    /// 		<term>the thread properties</term>
    /// 		<description>
    /// 		The <see cref="ThreadContext.Properties"/> that are set on the current
    /// 		thread. These properties are shared by all events logged on this thread.
    /// 		</description>
    /// 	</item>
    /// 	<item>
    /// 		<term>the global properties</term>
    /// 		<description>
    /// 		The <see cref="GlobalContext.Properties"/> that are set globally. These 
    /// 		properties are shared by all the threads in the AppDomain.
    /// 		</description>
    /// 	</item>
    /// </list>
    /// </para>
    /// </remarks>
    public object LookupProperty(string key) {
      if (m_data.Properties != null)
        return m_data.Properties[key];
      if (m_compositeProperties == null)
        CreateCompositeProperties();
      return m_compositeProperties[key];
    }

    /// <summary>
    /// Get all the composite properties in this event
    /// </summary>
    /// <returns>the <see cref="PropertiesDictionary"/> containing all the properties</returns>
    /// <remarks>
    /// <para>
    /// See <see cref="LookupProperty"/> for details of the composite properties 
    /// stored by the event.
    /// </para>
    /// <para>
    /// This method returns a single <see cref="PropertiesDictionary"/> containing all the
    /// properties defined for this event.
    /// </para>
    /// </remarks>
    public PropertiesDictionary GetProperties() {
      if (m_data.Properties != null)
        return m_data.Properties;
      if (m_compositeProperties == null)
        CreateCompositeProperties();
      return m_compositeProperties.Flatten();
    }

    #endregion Public Instance Methods

    #region Private Instance Fields

    /// <summary>
    /// The fully qualified Type of the calling 
    /// logger class in the stack frame (i.e. the declaring type of the method).
    /// </summary>
    readonly Type m_callerStackBoundaryDeclaringType;

    /// <summary>
    /// The application supplied message of logging event.
    /// </summary>
    readonly object m_message;

    /// <summary>
    /// The exception that was thrown.
    /// </summary>
    /// <remarks>
    /// This is not serialized. The string representation
    /// is serialized instead.
    /// </remarks>
    readonly Exception m_thrownException;

    /// <summary>
    /// Indicated that the internal cache is updateable (ie not fixed)
    /// </summary>
    /// <remarks>
    /// This is a seperate flag to m_fixFlags as it allows incrementel fixing and simpler
    /// changes in the caching strategy.
    /// </remarks>
    bool m_cacheUpdatable = true;

    /// <summary>
    /// The internal logging event data.
    /// </summary>
    CompositeProperties m_compositeProperties;

    /// <summary>
    /// The internal logging event data.
    /// </summary>
    LoggingEventData m_data;

    /// <summary>
    /// The internal logging event data.
    /// </summary>
    PropertiesDictionary m_eventProperties;

    /// <summary>
    /// The fix state for this event
    /// </summary>
    /// <remarks>
    /// These flags indicate which fields have been fixed.
    /// Not serialized.
    /// </remarks>
    FixFlags m_fixFlags = FixFlags.None;

    /// <summary>
    /// The repository that generated the logging event
    /// </summary>
    /// <remarks>
    /// This is not serialized.
    /// </remarks>
    ILoggerRepository m_repository;

    #endregion Private Instance Fields

    #region Constants

    /// <summary>
    /// The key into the Properties map for the host name value.
    /// </summary>
    public const string HostNameProperty = "log4net:HostName";

    /// <summary>
    /// The key into the Properties map for the thread identity value.
    /// </summary>
    public const string IdentityProperty = "log4net:Identity";

    /// <summary>
    /// The key into the Properties map for the user name value.
    /// </summary>
    public const string UserNameProperty = "log4net:UserName";

    #endregion
  }
}